//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include <math.h>
#include "ctrlstd.hrc"
#include "CDevise.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
#define MODULE_TAG    1461
#define DEFAUT_WIDTH  35
//---------------------------------------------------------------------------
AnsiString __fastcall SaisieTauxChange( CEditDevise *edDevise);
//---------------------------------------------------------------------------
class CInitDevises
{
  public:
    __fastcall  CInitDevises(void);
    virtual __fastcall ~CInitDevises(void);
};
//---------------------------------------------------------------------------
CDevise &__fastcall GetRefDevise(const TCodeDev nCode);
TCodeDev __fastcall GetPrimaryCodeDevise( void);
TCodeDev __fastcall GetFrancCodeDevise( void);
//---------------------------------------------------------------------------
TStringList *CEditDevise::CM_LstDevises = NULL;
CInitDevises Initialization;
//---------------------------------------------------------------------------
//AnsiString strCodeEuro( _CodePays==CP_FRANCE ? AnsiString( "EUR") : _CodePays==CP_TUNISIE ? AnsiString( "TND") : AnsiString( "ZZZ"));
//AnsiString strCodeEuro( "EUR");
const TCodeDev DeviseCodeEuro   = GetPrimaryCodeDevise(); //DEVCODE( AnsiString( "EUR"), false);
const TCodeDev DeviseCodeFranc  = GetFrancCodeDevise(); //DEVCODE( AnsiString( "FRF"), _CodePays==CP_FRANCE);

const CDevise &DeviseEuro       = GetRefDevise( DeviseCodeEuro   );
const CDevise &DeviseFranc      = GetRefDevise( DeviseCodeFranc  );

TCodeDev DeviseCodeDefaut;
CDevise *DeviseDefaut;
//---------------------------------------------------------------------------
// ValidCtrCheck est utilisé pour être sûr que les composants créés ne
// contiennent aucune fonction virtuelle pure.
//

static inline void ValidCtrCheck(CEditDevise *)
{
    new CEditDevise(NULL);
}
//---------------------------------------------------------------------------
TCodeDev __fastcall GetFrancCodeDevise( void)
{
  return DEVCODE( AnsiString( "FRF"), _CodePays==CP_FRANCE);
}
//---------------------------------------------------------------------------
TCodeDev __fastcall GetPrimaryCodeDevise( void)
{
       if( _CodePays==CP_FRANCE ) return DEVCODE( AnsiString( "EUR"), false);
  else if( _CodePays==CP_TUNISIE) return DEVCODE( AnsiString( "TND"), false);
  else                            ASSERT( false);
                                  return DEVCODE( AnsiString( "EUR"), false);
}
//---------------------------------------------------------------------------
CDevise &__fastcall GetRefDevise(const TCodeDev nCode)
{
  for(int i=CEditDevise::CM_LstDevises->Count-1; i>=0; i--) {
    CDevise *pDevInfos = (CDevise*)CEditDevise::CM_LstDevises->Objects[i];
    if (pDevInfos->Code==nCode) return (*pDevInfos);
  }
  ASSERT(false);
  return *((CDevise*)CEditDevise::CM_LstDevises->Objects[0]);
}
//---------------------------------------------------------------------------
/*
bool __fastcall DeviseGetTaux(TStrings *pLstTaux)
{
  return SaisieTauxConversion(pLstTaux);
}
*/
//---------------------------------------------------------------------------
/*
void __fastcall DeviseInitTaux(const TStrings *pLstTaux)
{
  TStrings *pItems = CEditDevise::CM_LstDevises;
  CDevise  *pDevise;
  char      cDevise[11][4] = { "DEM", "ATS", "BEF", "ESP",
                               "FIM", "FRF", "IEP", "ITL",
                               "LUF", "NLG", "PTE" };

  try {
    // Scrute toutes les devises et recherche celles qui sont
    // euro afin de leur affecter un taux saisie par l'utilisateur
    for(int nIndex=0; nIndex<((TStrings*)pLstTaux)->Count; nIndex++) {
      for(int i=0; i<pItems->Count; i++) {
        pDevise = (CDevise*)pItems->Objects[i];
        if (pDevise->EstDeviseEuro && (pDevise->CodeISO==AnsiString(cDevise[nIndex]))) {
          AnsiString strTauxConv(((TStrings*)pLstTaux)->Strings[nIndex]);
          if (PToV(strTauxConv).ToDouble()==0) throw EUser(TAG(35));
          pDevise->ForceTauxEuro( PToV(strTauxConv).ToDouble());
        }
      }
    }

  } catch (Exception &e) {
    throw EUser(TAG(350), e);
  }
}
*/
//---------------------------------------------------------------------------
/*
double __fastcall Round(double x, int nDecimales)
{
  if (nDecimales==NO_DECIMALES) return x;
  // Arrondi un montant à N décimales après la virgule
  // avec la méthode suivante
  // Si le (N+1)ième décimale >= 5 on arrondi à la Nième décimale supérieure
  double dEntier1, dFract1;                    // Exemple :
  double dEntier2, dFract2;                    // x = 123.456                       | x = 654.321
  double dTmp;
  double dValue = pow10(nDecimales);
  dFract1 = modf(x               , &dEntier1); // dEntier1 = 123 , dFract1 = 0.456  | dEntier1 = 654 , dFract1 = 0.321
  dTmp    = dFract1 * dValue;
  dFract2 = modf( dTmp, &dEntier2); // dEntier2 =  45 , dFract2 = 0.6    | dEntier2 =  32 , dFract2 = 0.1
  if (dFract2>=0.5) dEntier2++;                // dEntier2 =  46                    | dEntier2 =  32

  return  dEntier1 + (dEntier2 / dValue);      // 123.46                            | 654.32
}
*/
//---------------------------------------------------------------------------
AnsiString __fastcall DeviseTauxToStr(double dTaux)
{
  AnsiString strTaux( dTaux);
  int        nLenght = strTaux.Length();

  ASSERT( (int)dTaux==0 ? nLenght==8 : ((nLenght>=6) && (nLenght<=7)));

  if( strTaux.Pos( AnsiString( DecimalSeparator)) == 0) strTaux = strTaux + AnsiString( DecimalSeparator);
  // Met le taux euro sur 6 chiffres et 1 virgule
  while (strTaux.Length() < 7) strTaux = strTaux + "0";
  return strTaux;
}
//---------------------------------------------------------------------------
CCurrency __fastcall DeviseConvToDef(const CDevise &cInfosDev, const CCurrency &curMontantOrg)
{
  //ASSERT(cInfosDev.Taux > 0);
  if ( cInfosDev.Taux<=0) EICThrowInvalidArgument( TAG( 130));
  if( curMontantOrg.Vide) return curMontantOrg;

  double   dMontantEuro;
  Currency curMontant;
  bool     bEstNeg = (curMontantOrg<0);

  //curMontant = curMontantOrg < 0 ? -curMontantOrg : curMontantOrg;
  curMontant = Currency( Round( curMontantOrg < 0 ? 0-curMontantOrg : curMontantOrg, CurrencyDecimals));
  // Si la devise du montant à convertir est la même que
  // la devise du dossier alors on ne convertit rien
  if (cInfosDev.Code==DeviseCodeDefaut) return (bEstNeg ? -curMontant : curMontant);
  // Convertion de la devise du montant à convertir en Euro
  if (cInfosDev.EstDeviseEuro) dMontantEuro = (double)curMontant / cInfosDev.Taux;
                          else dMontantEuro = (double)curMontant * cInfosDev.Taux;
  // Si le dossier n'est pas en Euro, on convertit en Franc et on retourne cette valeur
  // sinon on retourne la valeur en Euro
  if (DeviseCodeDefaut==DeviseCodeEuro) return (bEstNeg ? -Currency(Round(dMontantEuro, CurrencyDecimals)) : Currency(Round(dMontantEuro, CurrencyDecimals)));
  ASSERT(DeviseCodeDefaut==DeviseCodeFranc);
  return (bEstNeg ? -Currency(Round(dMontantEuro*DeviseFranc.Taux, CurrencyDecimals)) : Currency(Round(dMontantEuro*DeviseFranc.Taux, CurrencyDecimals)));
}
//---------------------------------------------------------------------------
CCurrency __fastcall DeviseConvTo(const CDevise &cInfosDev, const CCurrency &curMontantOrg, const CDevise &cInfosDevTo)
{
  double   dMontantEuro;
  double   dMontantFinal;
  Currency curMontant;
  bool     bEstNeg = (curMontantOrg<0);

  if (cInfosDev  .Taux<=0) EICThrowInvalidArgument(TAG(100));
  if (cInfosDevTo.Taux<=0) EICThrowInvalidArgument(TAG(110));
  if( curMontantOrg.Vide) return curMontantOrg;

  //curMontant = curMontantOrg < 0 ? -curMontantOrg : curMontantOrg;
  curMontant = Currency( Round( curMontantOrg < 0 ? 0-curMontantOrg : curMontantOrg, CurrencyDecimals));
  // Si la devise de règlement est la même que la devise d'origine
  // on retourne simplement la valeur
  if (cInfosDev.Code==cInfosDevTo.Code) return (bEstNeg ? -curMontant : curMontant);
  // Convertit le montant en Euro
  // Si la taux vaut -1 la conversion est alors impossible
  if (cInfosDev.EstDeviseEuro) dMontantEuro = (double)curMontant / cInfosDev.Taux;
                          else dMontantEuro = (double)curMontant * cInfosDev.Taux;
  // Convertit le montant nouvellement calculé en Euro
  // en la devise de règlement
  if (cInfosDevTo.EstDeviseEuro) dMontantFinal = Round(dMontantEuro * cInfosDevTo.Taux, CurrencyDecimals);
                            else dMontantFinal = Round(dMontantEuro / cInfosDevTo.Taux, CurrencyDecimals);
  return (bEstNeg ? -Currency(dMontantFinal) : Currency(dMontantFinal));
}
//---------------------------------------------------------------------------
void __fastcall DeviseChangeDefaut(const TCodeDev nCodeDev)
{
  if( _CodePays==CP_FRANCE) {
    ASSERT(( nCodeDev==DeviseCodeEuro) || ( nCodeDev==DeviseCodeFranc));
    DeviseDefaut     = ( nCodeDev==DeviseCodeEuro) ? ( CDevise*)&DeviseEuro : ( CDevise*)&DeviseFranc;
    DeviseCodeDefaut =   nCodeDev;
  } else {
    ASSERT( nCodeDev==DeviseCodeEuro);
    DeviseDefaut     = ( CDevise*)&DeviseEuro;
    DeviseCodeDefaut =   nCodeDev;
  }
}
//---------------------------------------------------------------------------
AnsiString __fastcall DeviseGetStringDeviseTenue(const bool bIsEuro)
{
  if( _CodePays==CP_FRANCE) return bIsEuro ? "Dossier tenu en Euros" : "Dossier tenu en Francs";
                       else return EmptyStr;
}
//---------------------------------------------------------------------------
bool __fastcall DeviseEstValide(const TDateTime &dtDateImputation, const CDevise &cInfosDev, AnsiString &strErrorMsg)
{
  // Vérifie que l'on ne saisie pas une devise Euro ou étrangère avant le 1er janvier 1999
  if ((dtDateImputation < TDateTime(1999, 1, 1)) && (cInfosDev.Code!=DeviseCodeFranc)) {
    if( _CodePays==CP_FRANCE) {
      strErrorMsg = EICFormat("Vous ne pouvez pas saisir une écriture en %s avant le 1er janvier 1999.", cInfosDev.Nom.c_str());
      return false;
    }
  }
  // Vérifie que l'on ne saisie pas de devise Européenne après le 1er janvier 2002
/*  if ((dtDateImputation >= TDateTime(2002, 1, 1)) && cInfosDev.EstDeviseEuro) {
    if( _CodePays==CP_FRANCE) {
      strErrorMsg = EICFormat("Vous ne pouvez pas saisir une écriture en %s après le 31 décembre 2001.", cInfosDev.Nom.c_str());
      return false;
    }
  }*/
  // Pas de date invalide
  return true;
}
//---------------------------------------------------------------------------
TCodeDev __fastcall DeviseGetCodeDev( const AnsiString &strCodeISO)
{
  ASSERT( CEditDevise::CM_LstDevises);
  for( int i=CEditDevise::CM_LstDevises->Count-1; i>=0; i--) {
    CDevise *devise = ( CDevise*)CEditDevise::CM_LstDevises->Objects[i];
    if ( devise->CodeISO==strCodeISO) return devise->Code;
  }
  throw EUser( TAG( 120), "Le code devise demandé n'existe pas !");
}
//---------------------------------------------------------------------------
void __fastcall DeviseGetListCodeISO( TStrings *pListCodeDevise)
{
  pListCodeDevise->Clear();
  for( int i=0; i<CEditDevise::CM_LstDevises->Count; i++) {
    CDevise *pDevise = ( CDevise*)CEditDevise::CM_LstDevises->Objects[i];
    pListCodeDevise->Add( pDevise->Code);
  }
}
//---------------------------------------------------------------------------
#define MAKECOLUMN( pColumn, eAlignment, strCaption, nWidth) { pColumn->Alignment = eAlignment; \
                                                               pColumn->Caption   = strCaption; \
                                                               pColumn->Width     = nWidth; }
#define MAKELISTITEM( pItem, strDevise, strISO, strPays) { pItem->Caption = strPays; \
                                                           pItem->SubItems->Add( strISO); \
                                                           pItem->SubItems->Add( strDevise); }
//---------------------------------------------------------------------------
__fastcall CEditDevise::CEditDevise(TComponent* Owner)
    : CCustomEdit(Owner)
{
//  m_bKeyDown       = false;
  m_nWidth         = 100;
  CharCase         = ecUpperCase; // Saisie toujours en majuscules
  MaxLength        = 3;           // Les codes ISO sur 3 caractères
  m_strSaveCodeISO = DeviseEuro.CodeISO;
  m_bEnabled       = true;
  m_nSizeEsp       = 10;
  m_bReadOnly      = false;
  m_bShowEditTaux  = true;
  m_bTabStop       = true;
  m_bVisible       = true;
  m_bKillFocus     = false;
  m_bDefValue      = true;
  m_bInitSort      = false;
  m_pColumnSort    = NULL;

  m_pDeviseChangeEvent  = NULL;
  m_pOnExit             = NULL;
  m_pOnExitTaux         = NULL;

  CCustomEdit::OnChange = edOnChange;
  CCustomEdit::OnExit   = edOnExit;

  // Création du bouton d'accès à la liste des devises
  m_psbListe  = NULL;
  m_pedTaux   = NULL;
  m_pfrmListe = NULL;
  m_pLabel    = NULL;
  m_psbTaux   = NULL;
  m_pedTaux   = new CEdit    ( this);
  m_psbListe  = new TBitBtn  ( this);
  m_psbTaux   = new TBitBtn  ( this);
  m_pfrmListe = new TForm    ( this);
//  m_plbDevise = new CListBox    ( this);
  m_pLabel    = new TLabel   ( this);
  m_plvDevise = new TListView( this);

//  m_psbListe ->Flat      = true;
  m_psbListe ->OnClick   = sbListeClick;
  m_psbListe ->NumGlyphs = 2;
  m_psbListe ->TabStop   = false;
  m_psbListe ->Glyph->LoadFromResourceName(( int)HInstance, "ARROW");

  m_psbTaux  ->OnClick = sbTauxClick;
  m_psbTaux  ->OnEnter = sbTauxOnEnter;
  m_psbTaux  ->TabStop   = false;
  m_psbTaux  ->Glyph->LoadFromResourceName(( int)HInstance, "3POINTS");

  m_pedTaux  ->Alignment     = taRightJustify;
  m_pedTaux  ->Filtres      << CCustomEdit::feTotal;
  m_pedTaux  ->OnIllegalChar = edTauxOnIllegalChar;
  m_pedTaux  ->OnExit        = edTauxOnExit;
  m_pedTaux  ->OnChange      = edTauxOnChange;
  m_pedTaux  ->OnDblClick    = edTauxOnDblClick;
  m_pedTaux  ->OnEnter       = edTauxOnEnter;

  m_pfrmListe->Width        = 386;
  m_pfrmListe->Height       = /*m_plvDevise->ItemHeight*/16 * 8 + 2;
//  m_pfrmListe->BorderStyle  = bsToolWindow;
  m_pfrmListe->BorderStyle  = bsNone;
//  m_pfrmListe->Caption      = "Sélection d'une devise";
  m_pfrmListe->OnDeactivate = frmListeOnDeactivate;

  m_plvDevise->Parent    = m_pfrmListe;
  m_plvDevise->Align     = alClient;
  m_plvDevise->ViewStyle = vsReport;
  m_plvDevise->RowSelect = true;
  TListColumn *pColumn = m_plvDevise->Columns->Add(); MAKECOLUMN( pColumn, taLeftJustify, "Pays"  , 170);
               pColumn = m_plvDevise->Columns->Add(); MAKECOLUMN( pColumn, taCenter     , "ISO"   ,  40);
               pColumn = m_plvDevise->Columns->Add(); MAKECOLUMN( pColumn, taLeftJustify, "Devise", 150);
  for( int i=0; i<CM_LstDevises->Count; i++) {
    TListItem *pItem  = m_plvDevise->Items->Add();
    CDevise   *devise = ( CDevise*)CM_LstDevises->Objects[i];
    MAKELISTITEM( pItem, devise->Nom, devise->CodeISO, devise->Pays);
  }
  m_plvDevise->Ctl3D     = false;
  m_plvDevise->ReadOnly  = true;
  m_plvDevise->OnColumnClick = ColumnClick;
  m_plvDevise->OnClick       = lvDeviseOnClick;
  m_plvDevise->OnKeyDown     = lvDeviseOnKeyDown;

//  m_plbDevise->Parent       = m_pfrmListe;
//  m_plbDevise->Align        = alClient;
//  m_plbDevise->BorderStyle = bsNone;
//  m_plbDevise->Style        = lbOwnerDrawFixed;
//  m_plbDevise->OnDrawItem   = lbDeviseOnDrawItem;
//  m_plbDevise->OnClick      = lbDeviseOnClick;
//  m_plbDevise->OnKeyDown    = lbDeviseOnKeyDown;
//  m_plbDevise->OnKeyUp      = lbDeviseOnKeyUp;
//  m_plbDevise->Items->Assign( CM_LstDevises);
//  m_plbDevise->Visible = false;

  m_pLabel   ->Transparent  = true;
  m_pLabel   ->FocusControl = this;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::lvDeviseOnClick( TObject *pSender)
{
  if ( m_plvDevise->Selected) { // Pour la version OSR1 de Win95, car le propriété RowSelected n'existe pas
    Text = m_plvDevise->Selected->SubItems->Strings[0];
    SetFocus();
  }
}
//---------------------------------------------------------------------------
int __stdcall CustomSortListView( long Item1, long Item2, long ParamSort)
{
  TListItem *pItem1 = ( TListItem*)Item1;
  TListItem *pItem2 = ( TListItem*)Item2;

  switch ( abs( ParamSort)) {
    case 1 : return (( ParamSort>0) ? 1 : -1)*strcmp( pItem1->Caption.c_str()             , pItem2->Caption.c_str()             );
    case 2 : return (( ParamSort>0) ? 1 : -1)*strcmp( pItem1->SubItems->Strings[0].c_str(), pItem2->SubItems->Strings[0].c_str());
    case 3 : return (( ParamSort>0) ? 1 : -1)*strcmp( pItem1->SubItems->Strings[1].c_str(), pItem2->SubItems->Strings[1].c_str());
  }
  return 0;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::ColumnClick( TObject *pSender, TListColumn *pColumn)
{
  m_plvDevise->CustomSort( CustomSortListView, (pColumn==m_pColumnSort ? -1 : 1)*(pColumn->Index+1));
  if ( m_pColumnSort==pColumn) m_pColumnSort = NULL;
                          else m_pColumnSort = pColumn;

  if ( m_plvDevise->Selected) m_plvDevise->Selected->MakeVisible( false);
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::edTauxOnChange( TObject *pSender)
{
  try {
    m_devInfos.Taux = m_pedTaux->Text.ToDouble();
    if ( OnChange) OnChange( this, !m_pedTaux->Text.IsEmpty() && !Text.IsEmpty() && ( m_devInfos.Taux>0));
  } catch ( ...) { m_devInfos.Taux = -1;                         }
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::edTauxOnDblClick( TObject *pSender)
{
  if ( m_pedTaux->Enabled && !m_pedTaux->ReadOnly) {
    try         { m_pedTaux->Text = SaisieTauxChange( this).ToDouble(); }
    catch( ...) { m_pedTaux->Text = EmptyStr;                           }
    m_pedTaux->SelectAll();
    m_pedTaux->SetFocus();
  }
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::edTauxOnEnter( TObject *pSender)
{
  //if(( m_pedTaux->Text.IsEmpty()) && ( _CodePays==CP_FRANCE)) edTauxOnDblClick( m_pedTaux);
  if( m_pedTaux->Text.IsEmpty()) edTauxOnDblClick( m_pedTaux);
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::sbTauxClick( TObject *pSender)
{
  edTauxOnDblClick( m_pedTaux);
  m_pedTaux->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::sbTauxOnEnter( TObject *pSender)
{
  if( m_pedTaux->Text.IsEmpty()) m_pedTaux->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetTauxChange( double dTaux)
{
  if ( m_devInfos.EstDeviseEuro) return;
  m_pedTaux->Text = AnsiString( dTaux);
}
//---------------------------------------------------------------------------
double __fastcall CEditDevise::GetTauxChange() const
{
  try          { return m_pedTaux->Text.ToDouble(); }
  catch ( ...) { return -1;                         }
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetCodeDevise( TCodeDev nValue)
{
  try                  { Text = CDevise( nValue, 1).CodeISO;  }
  catch (Exception &e) { EICThrowInvalidArgument( TAG( 300)); }
}
//---------------------------------------------------------------------------
TCodeDev __fastcall CEditDevise::GetCodeDevise() const
{
  return m_devInfos.Code;
}
//---------------------------------------------------------------------------
AnsiString __fastcall CEditDevise::GetCodeISO() /*const*/
{
  return Text;
}
//---------------------------------------------------------------------------
CDevise __fastcall CEditDevise::GetDeviseInfos() const
{
  return m_devInfos;
};
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetVisible( bool bValue)
{
            m_bVisible = bValue;
  CCustomEdit::Visible = m_bVisible;
    m_pedTaux->Visible = m_bVisible && m_bShowEditTaux;
   m_psbListe->Visible = m_bVisible;
    m_psbTaux->Visible = m_bVisible;
     m_pLabel->Visible = m_bVisible;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetText( const AnsiString strValue)
{
  CCustomEdit::Text = strValue;
}
//---------------------------------------------------------------------------
AnsiString __fastcall CEditDevise::GetText() /*const*/
{
  return CCustomEdit::Text;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetTabStop( bool bValue)
{
  m_bTabStop		   = bValue;
  CCustomEdit::TabStop = m_bTabStop;
//  m_pedTaux  ->TabStop = m_bTabStop;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetSizeEspace( int nValue)
{
  m_nSizeEsp     = nValue;
  m_pLabel->Top  = Top + 3;
  m_pLabel->Left = Left  - m_pLabel->Width - m_nSizeEsp;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetShowEditTaux( bool bValue)
{
  m_bShowEditTaux    = bValue;
  m_pedTaux->Visible = m_bShowEditTaux;
  m_psbTaux->Visible = m_bShowEditTaux; 
//  m_pedTaux->Parent  = m_bShowEditTaux ? Parent : NULL;
}
//---------------------------------------------------------------------------
bool __fastcall CEditDevise::GetReadOnly() const
{
  return m_bReadOnly;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetReadOnly( bool bValue)
{
  m_bReadOnly = bValue;
  CCustomEdit::ReadOnly =  m_bReadOnly;
  m_pedTaux  ->ReadOnly = (m_bReadOnly || m_devInfos.EstDeviseEuro || ( m_devInfos.Code==DeviseCodeEuro));
  m_psbListe ->Enabled  = !m_bReadOnly && Enabled;
  m_psbTaux  ->Enabled  = !m_pedTaux->ReadOnly && Enabled;
}
//---------------------------------------------------------------------------
TFont *__fastcall CEditDevise::GetLibelleFont() const
{
  return m_pLabel->Font;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetLibelleFont( TFont *pFont)
{
  m_pLabel->Font->Assign( pFont);
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetLibelle( const AnsiString strValue)
{
  m_pLabel->Visible = Visible;
  m_pLabel->Enabled = Enabled;
  m_pLabel->Parent  = Parent;
  m_pLabel->Caption = strValue;
  m_pLabel->Top     = Top + 3;
  m_pLabel->Left    = Left  - m_pLabel->Width - m_nSizeEsp;
}
//---------------------------------------------------------------------------
AnsiString __fastcall CEditDevise::GetLibelle() const
{
  return m_pLabel->Caption;
}
//---------------------------------------------------------------------------
bool __fastcall CEditDevise::GetEnabled()
{
  return m_bEnabled;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetEnabled( bool bValue)
{
            m_bEnabled = bValue;
     m_pLabel->Enabled = m_bEnabled;
    m_pedTaux->Enabled = m_bEnabled;
  CCustomEdit::Enabled = m_bEnabled;
  SetReadOnly( m_bReadOnly);
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetWidth( int nValue)
{
  if ( nValue!=DEFAUT_WIDTH) {
    m_nWidth         = nValue;
    m_pedTaux->Width = m_nWidth;
  }
  CCustomEdit::Width = DEFAUT_WIDTH;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::FORCE_SAISIE_TAUX()
{
  if ( !ShowEditTaux) return;
  // Beurk, ca me fais ..............
  //::EICAttention( "Vous n'avez pas saisi de taux de change pour cette devise !\nVeuillez en saisir un avant de continuer.");
  //m_pedTaux->SetFocus();
  try {
    SetFocus();
    if( ::EICMsgBox( "Vous n'avez pas saisi de taux de change pour cette devise !\nVeuillez en saisir un avant de continuer.", "Attention", MB_ICONWARNING | MB_OKCANCEL)==IDOK)
        m_pedTaux->SetFocus();
  } catch( Exception &e) {
  }
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::edTauxOnExit( TObject *pSender)
{
  TWinControl *pwcActive = GetParentForm( this)->ActiveControl;
  if (( pwcActive!=this) && ( pwcActive!=m_psbTaux) && m_pedTaux->Text.IsEmpty()) FORCE_SAISIE_TAUX();
//  if ( m_pedTaux->Text.IsEmpty()) m_pedTaux->Text = "1";
  if( m_pOnExitTaux) m_pOnExitTaux( pSender);
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::edOnExit( TObject *pSender)
{
  switch( _CodePays) {
    case CP_FRANCE  : if ( Text=="F") Text = DeviseFranc.CodeISO;
                      if ( Text=="E") Text = DeviseEuro .CodeISO;
                      break;
    case CP_TUNISIE : if ( Text=="T") Text = DeviseEuro .CodeISO;
                      break;
    default         : ASSERT( false); break;
  }

  if ( CM_LstDevises->IndexOf( Text)==-1) {
    if ( m_bDefValue) Text = m_strSaveCodeISO;
    if ( !m_devInfos.EstDeviseEuro && m_pedTaux->Text.IsEmpty()) FORCE_SAISIE_TAUX();
  }
  m_strSaveCodeISO = Text;

  if ( m_pOnExit) m_pOnExit( pSender);
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::edTauxOnIllegalChar(CCustomEdit *pedSender, WORD &cIllegalCharCode, bool &bAccept)
{
  // Liste des caractères acceptés dans l'edit du taux de conversion
  // Caractères acceptés '0'-'9', '.'
  bAccept = (( cIllegalCharCode>='0') && ( cIllegalCharCode<='9')) || ( cIllegalCharCode=='.') || ( cIllegalCharCode=='\b');

  if( cIllegalCharCode=='.') cIllegalCharCode = DecimalSeparator;
  if( cIllegalCharCode==DecimalSeparator) bAccept &= ( m_pedTaux->Text.Pos( DecimalSeparator)==0);
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::lvDeviseOnKeyDown( TObject* pSender, Word &Key, TShiftState Shift)
{
  if ( Key==VK_RETURN) { lvDeviseOnClick( m_plvDevise); return; }
  if ( Key==VK_ESCAPE) { SetFocus(); return; }
//  m_bKeyDown = true;
}
//---------------------------------------------------------------------------
/*
void __fastcall CEditDevise::lbDeviseOnKeyUp( TObject* pSender, Word &Key, TShiftState Shift)
{
  m_bKeyDown = false;
}
*/
//---------------------------------------------------------------------------
void __fastcall CEditDevise::edOnChange( TObject *pSender)
{
  int nIndex;
  /*if ( Text.IsEmpty())*/
  /*if ( !m_bKillFocus)*/ { /*m_pedTaux->ReadOnly = false;*/ m_pedTaux->Text = EmptyStr; }
  if ( Text.Length()!=3) return;

  nIndex = CM_LstDevises->IndexOf( Text);
  if ( nIndex==-1) { Text = EmptyStr; return; }

  m_devInfos = *( CDevise*)CM_LstDevises->Objects[nIndex];

  m_pedTaux->ReadOnly = m_devInfos.EstDeviseEuro || ( m_devInfos.Code==DeviseCodeEuro) || m_bReadOnly;
  m_psbTaux->Enabled  = !m_pedTaux->ReadOnly;

  if ( m_devInfos.EstDeviseEuro || ( m_devInfos.Code==DeviseCodeEuro)) {
    m_pedTaux->Text = AnsiString( m_devInfos.Taux);
    #ifdef _DEBUG
      if (!IS_MACHINE_INFORMATICIEN()) m_pedTaux->Font->Color = clBtnFace;
    #else
      m_pedTaux->Font->Color = clBtnFace;
    #endif
  } else {
    /*if ( !m_bKillFocus)*/ m_pedTaux->Text = EmptyStr;
    m_pedTaux->Font->Color = clWindowText;
  }

  if ( OnChange) OnChange( this, !m_pedTaux->Text.IsEmpty() && !Text.IsEmpty() && ( m_devInfos.Taux>0));
  m_bKillFocus = false;
}
//---------------------------------------------------------------------------
/*
void __fastcall CEditDevise::lbDeviseOnClick( TObject *pSender)
{
  if ( m_bKeyDown) return;
  Text = m_plbDevise->Items->Strings[ m_plbDevise->ItemIndex];
  SetFocus();
}
*/
//---------------------------------------------------------------------------
void __fastcall CEditDevise::Loaded()
{
  CCustomEdit::Loaded();

  if ( m_psbListe) m_psbListe->TabOrder = TabOrder + 1;
  if ( m_pedTaux ) m_pedTaux ->TabOrder = TabOrder + 2;
  if ( m_psbTaux ) m_psbTaux ->TabOrder = TabOrder + 3;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetParent( TWinControl* pAParent)
{
  CCustomEdit::SetParent( pAParent);
  if ( pAParent==NULL) return;
  if ( m_psbListe) m_psbListe->Parent = pAParent;
  if ( m_pedTaux ) m_pedTaux ->Parent = pAParent;
  if ( m_psbTaux ) m_psbTaux ->Parent = pAParent;
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::frmListeOnDeactivate( TObject *pSender)
{
  m_pfrmListe->Visible = false;
}
//---------------------------------------------------------------------------
/*
void __fastcall CEditDevise::lbDeviseOnDrawItem( TWinControl* pControl, int nIndex, const TRect &sRect, TOwnerDrawState sState)
{
  ASSERT( dynamic_cast< TCustomListBox*>( pControl));

  TCanvas *pCanvas   = dynamic_cast< TCustomListBox*>( pControl)->Canvas;
  CDevise *pDevInfos = ( CDevise*)m_plbDevise->Items->Objects[nIndex];
  // Efface la zone avec la couleur prédéfinie
  pCanvas->FillRect( sRect);
  pCanvas->TextOut ( sRect.Left+2  , sRect.Top, pDevInfos->Nom);
  pCanvas->TextOut ( sRect.Left+170, sRect.Top, pDevInfos->CodeISO);
  pCanvas->TextOut ( sRect.Left+210, sRect.Top, pDevInfos->Pays);
  // Affichage des séparateurs
  pCanvas->Pen->Color = clLtGray;
  pCanvas->MoveTo  ( sRect.Left+165, sRect.Top   );
  pCanvas->LineTo  ( sRect.Left+165, sRect.Bottom);
  pCanvas->MoveTo  ( sRect.Left+200, sRect.Top   );
  pCanvas->LineTo  ( sRect.Left+200, sRect.Bottom);
}
*/
//---------------------------------------------------------------------------
void __fastcall CEditDevise::sbListeClick( TObject *pSender)
{
  TPoint point;
  // Place la fenêtre au bonne endroit
  point.x = Left;
  point.y = Top + Height;
  point   = Parent->ClientToScreen( point);
  if (( point.x + m_pfrmListe->Width) > Screen->Width) point.x = ( Screen->Width-m_pfrmListe->Width);
  m_pfrmListe->Left = point.x;
  m_pfrmListe->Top  = point.y;
  // Sélectionne la devise en cours
  m_plvDevise->Selected = m_plvDevise->Items->Item[0];
  for( int i=m_plvDevise->Items->Count-1; i>=0; i--)
    if ( m_plvDevise->Items->Item[i]->SubItems->Strings[0]==Text)
      m_plvDevise->Selected = m_plvDevise->Items->Item[i];
  // Donne la focalisation à la liste des devises recensées
  m_pfrmListe->Visible = true;
  if ( !m_bInitSort) { m_plvDevise->OnColumnClick( m_plvDevise, m_plvDevise->Columns->Items[0]); m_bInitSort = true; }
  m_pfrmListe->SetFocus();
  m_pfrmListe->BringToFront();

  //ASSERT( m_plvDevise->Selected);
  if ( m_plvDevise->Selected) m_plvDevise->Selected->MakeVisible( false);
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetCodeISOFocus()
{
  if ( Enabled || !ReadOnly) SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::SetTauxFocus()
{
  if ( m_pedTaux->Enabled || !m_pedTaux->ReadOnly) m_pedTaux->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall CEditDevise::WndProc( TMessage &Message)
{
  Cardinal uMsg = Message.Msg;
  CCustomEdit::WndProc( Message);

  switch ( uMsg) {
    case WM_WINDOWPOSCHANGED : // Repositionnement des composants associés
                               Width              = DEFAUT_WIDTH;
                               m_psbListe->Left   = Left + DEFAUT_WIDTH - 1;
                               m_psbListe->Top    = Top;
                               m_psbListe->Height = Height;
                               m_psbListe->Width  = 17;
                               m_pedTaux ->Left   = m_psbListe->Left + m_psbListe->Width;
                               m_pedTaux ->Top    = Top;
                               m_pedTaux ->Height = Height;
                               m_pedTaux ->Width  = m_nWidth;
                               m_pLabel  ->Top    = Top + 3;
                               m_pLabel  ->Left   = Left - m_pLabel->Width - m_nSizeEsp;
                               m_psbTaux ->Top    = Top;
                               m_psbTaux ->Left   = m_pedTaux->Left + m_pedTaux->Width - 1;
                               m_psbTaux ->Height = Height;
                               m_psbTaux ->Width  = Height+1;
                               break;
    case WM_KILLFOCUS        : { HWND h = ( HWND)Message.WParam;
                                 if ((( h==m_psbListe->Handle) /*|| ( h==m_psbTaux->Handle)*/) && m_pedTaux->Text.IsEmpty()) m_pedTaux->Text = "1";
//                               if (( h!=m_pedTaux->Handle) && ( h!=Handle) && ( h!=m_plvDevise->Handle) && m_pedTaux->Text.IsEmpty()) {
//                                  m_pedTaux->Text = "1";
//                                 }
//                                bool b = ( h!=m_pedTaux->Handle) && ( h!=Handle) && ( h!=m_plvDevise->Handle) && ( h!=m_psbTaux->Handle) && ( ::GetActiveWindow()==::GetParentForm( this)->Handle) && m_pedTaux->Text.IsEmpty() && ( CM_LstDevises->IndexOf( Text)!=-1);
                                if (( h!=m_pedTaux->Handle) && ( h!=Handle) && ( h!=m_plvDevise->Handle) && ( h!=m_psbTaux->Handle) && ( ::GetActiveWindow()==::GetParentForm( this)->Handle) && m_pedTaux->Text.IsEmpty() && ( CM_LstDevises->IndexOf( Text)!=-1))
                                  FORCE_SAISIE_TAUX();
                                m_bKillFocus = true;
                               }
                               break;
    case WM_SETFOCUS         : m_bKillFocus = false;
                               break;
    case CM_FONTCHANGED      : m_pedTaux->Font->Assign( Font);
                               break;
    default                  : break;
  }
}
//---------------------------------------------------------------------------
//----- Class::CDevise ------------------------------------------------------
//---------------------------------------------------------------------------
__fastcall CDevise::CDevise(TCodeDev nCode, double dTaux /* = -1 */)
{
  // Si le code est le code de sélection de la devise courante
  // on affecte à l'objet les propriétés de la devise par défaut
  if (nCode==CODE_DEVISE_DEFAUT) { *this = *DeviseDefaut; return; }

  for(int i=CEditDevise::CM_LstDevises->Count-1; i>=0; i--) {
    CDevise *pDevInfos = (CDevise*)CEditDevise::CM_LstDevises->Objects[i];
    if (pDevInfos->Code==nCode) {
      *this = *pDevInfos;
      if ((!pDevInfos->EstDeviseEuro) && (dTaux<=0)) EICThrowInvalidArgument(TAG(210));
      if (( nCode==DeviseCodeEuro)    && (dTaux!=1)) EICThrowInvalidArgument(TAG(220));
      Taux  =  dTaux;
      return;
    }
  }
  EICThrowInvalidArgument(TAG(200));
}
__fastcall CDevise::CDevise(const AnsiString &NomPays,const AnsiString &NomDevise,const AnsiString &CodeDevise,double dTaux)
{
  strNomPays    = NomPays; // Pays
  if (strNomPays.Length()>23) strNomPays = strNomPays.SubString(1, 20) + "...";
  strNomDevise  = NomDevise; // Nom de la devise
  strCodeISO    = CodeDevise; // Code de la devise
  if( _CodePays==CP_FRANCE) {
    if (dTaux == 0.0) {
      // La devise n'est pas une devise Euro car elle n'a pas de taux
      bDeviseEuro         = false;
      dTauxDeviseVersEuro = (strCodeISO=="EUR") ? 1 : -1;
    } else {
      // La devise est une devise Euro car elle possède un taux
      bDeviseEuro         = true;
      dTauxDeviseVersEuro = dTaux;
    }
  } else {
    ASSERT( _CodePays==CP_TUNISIE);
    // Pour les devises autres, il n'y pas de devise Euro toutes les monnaies sont OUT
    bDeviseEuro         = false;
    dTauxDeviseVersEuro = ( strCodeISO=="TND") ? 1 : -1;
  }
  // Création du code de la devise en entier
  nCode = DEVCODE(strCodeISO, bDeviseEuro);
}
//---------------------------------------------------------------------------
/*__fastcall CDeviseString::CDeviseString(const AnsiString &strDevisesInfos)
{
  AnsiString szStr(strDevisesInfos);
  int        nPosVirg;

  // Extraction du pays
  nPosVirg      = szStr.Pos(","); ASSERT(nPosVirg);
  strNomPays    = szStr.SubString(1         , nPosVirg-1             ); // Pays
  szStr         = szStr.SubString(nPosVirg+1, szStr.Length()-nPosVirg);
  if (strNomPays.Length()>23) strNomPays = strNomPays.SubString(1, 20) + "...";
  // Extraction de la devise
  nPosVirg      = szStr.Pos(","); ASSERT(nPosVirg);
  strNomDevise  = szStr.SubString(1         , nPosVirg-1             ); // Nom de la devise
  szStr         = szStr.SubString(nPosVirg+1, szStr.Length()-nPosVirg);
  // Extraction du code de la devise
  nPosVirg      = szStr.Pos(","); ASSERT(nPosVirg);
  strCodeISO    = szStr.SubString(1         , nPosVirg-1             ); // Code de la devise
  szStr         = szStr.SubString(nPosVirg+1, szStr.Length()-nPosVirg);
  // Extraction du flag
  if( _CodePays==CP_FRANCE) {
    if ((nPosVirg = szStr.Pos(",")) == 0) {
      // La devise n'est pas une devise Euro car elle n'a pas de taux
      bDeviseEuro         = false;
      dTauxDeviseVersEuro = (strCodeISO=="EUR") ? 1 : -1;
    } else {
      // La devise est une devise Euro car elle possède un taux
                      ASSERT(szStr.SubString(1         , nPosVirg-1             )=="256");
      bDeviseEuro         = (szStr.SubString(1         , nPosVirg-1             )=="256");
      szStr               =  szStr.SubString(nPosVirg+1, szStr.Length()-nPosVirg);
      //if ((nPosVirg = szStr.Pos(".")) != 0) szStr[nPosVirg] = ',';
      //dTauxDeviseVersEuro =  szStr.ToDouble();
      dTauxDeviseVersEuro =  ::atof( szStr.c_str());
    }
  } else {
    ASSERT( _CodePays==CP_TUNISIE);
    // Pour les devises autres, il n'y pas de devise Euro toutes les monnaies sont OUT
    bDeviseEuro         = false;
    dTauxDeviseVersEuro = ( strCodeISO=="TND") ? 1 : -1;
  }
  // Création du code de la devise en entier
  nCode = DEVCODE(strCodeISO, bDeviseEuro);
}*/
//---------------------------------------------------------------------------
void __fastcall CDevise::Clear()
{
  strCodeISO          = EmptyStr;
  strNomDevise        = EmptyStr;
  strNomPays          = EmptyStr;
  dTauxDeviseVersEuro = -1;
  nCode               = -1;
}
//---------------------------------------------------------------------------
void __fastcall CDevise::ForceTauxEuro(double dTaux)
{
  ASSERT(EstDeviseEuro);
  if (dTaux==0) return; // Aucun taux de conversion n'a été saisie
  dTauxDeviseVersEuro = dTaux;
}
//---------------------------------------------------------------------------
void __fastcall CDevise::SetTaux(double dTaux)
{
  //if ( bDeviseEuro) throw Exception("Taux de conversion non modifiable");
  if (!bDeviseEuro) dTauxDeviseVersEuro = dTaux;
}
//---------------------------------------------------------------------------
CDevise &__fastcall CDevise::operator =(const CDevise &pDevInfos)
{
  strCodeISO          = pDevInfos.strCodeISO;
  strNomDevise        = pDevInfos.strNomDevise;
  strNomPays          = pDevInfos.strNomPays;
  dTauxDeviseVersEuro = pDevInfos.dTauxDeviseVersEuro;
  bDeviseEuro         = pDevInfos.bDeviseEuro;
  nCode               = pDevInfos.nCode;
  return *this;
}
//---------------------------------------------------------------------------
bool __fastcall CDevise::operator ==(const CDevise &pDevInfos)
const
{
  if (bDeviseEuro) return  (nCode==pDevInfos.nCode);
              else return ((nCode==pDevInfos.nCode) && (dTauxDeviseVersEuro==pDevInfos.dTauxDeviseVersEuro));
}
//---------------------------------------------------------------------------
bool __fastcall CDevise::operator!=(const CDevise &pDevInfos)
const
{
 return( ( *this == pDevInfos) ^ true);
}
//---------------------------------------------------------------------------
bool __fastcall CDevise::operator<(const CDevise &pDevInfos)
const
{
 return strNomDevise < pDevInfos.strNomDevise;
}
//---------------------------------------------------------------------------
bool __fastcall CDevise::GetDeviseHorsZoneEuro() const
{
  return !bDeviseEuro && (nCode!=DeviseCodeEuro);
}
//---------------------------------------------------------------------------
//----- Class::CInitDevise --------------------------------------------------
//---------------------------------------------------------------------------
class TabDevises
{
public:
  char *NomPays,*NomDevise,*CodeDevise;
  double Taux;
};
const TabDevises ToutesLesDevises[] =
{//NomPays
  // Page 1                                                                ,NomDevise                          ,CodeD,Taux
  {"AFGHANISTAN"                                                           ,"Afghani"                          ,"AFA",   0.0},
  {"AFRIQUE DU SUD"                                                        ,"Rand"                             ,"ZAR",   0.0},
  {"ALBANIE"                                                               ,"Lek"                              ,"ALL",   0.0},
  {"ALGERIE"                                                               ,"Dinar algérien"                   ,"DZD",   0.0},
  {"ALLEMAGNE"                                                             ,"Deutsche mark"                    ,"DEM",   1.95583},
  // Page 2
//  {"ANDORRE"                                                               ,"Peseta"                           ,"ADP", 166.386},
  {"ANGOLA"                                                                ,"Kwanza réajusté"                  ,"AOR",   0.0},
  {"ANTILLES néerlandaises"                                                ,"Florin des Antilles néerlandaises","ANG",   0.0},
  {"ARABIE SAOUDITE"                                                       ,"Rial"                             ,"SAR",   0.0},
  {"ARGENTINE"                                                             ,"Peso"                             ,"ARS",   0.0},
  {"ARMENIE"                                                               ,"Dram"                             ,"AMD",   0.0},
  {"ARUBA"                                                                 ,"Florin"                           ,"AWG",   0.0},
  {"AUSTRALIE"                                                             ,"Dollar australien"                ,"AUD",   0.0},
  {"AUTRICHE"                                                              ,"Schilling"                        ,"ATS",  13.7603},
  // Page 3
  {"AZERBAIDJAN"                                                           ,"Manat"                            ,"AZM",   0.0},
  {"BAHAMAS"                                                               ,"Dollar de Bahamas"                ,"BSD",   0.0},
  {"BAHREIN"                                                               ,"Dinar de Bahrein"                 ,"BHD",   0.0},
  {"BANGLADESH"                                                            ,"Taka"                             ,"BDT",   0.0},
  {"BARBADE"                                                               ,"Dollar de Barbade"                ,"BBD",   0.0},
  {"BELGIQUE"                                                              ,"Franc belge"                      ,"BEF",  40.3399},
  {"BELIZE"                                                                ,"Dollar de Belizé"                 ,"BZD",   0.0},
  {"BENIN/BURKINA FASO/COTE-D'IVOIRE/GUINEE BISSAO/MALI/NIGER/SENEGAL/TOGO","Franc CFA"                        ,"XOF",   0.0},
  {"BERMUDES"                                                              ,"Dollar des Bermudes"              ,"BMD",   0.0},
  // Page 4
  {"BHOUTAN"                                                               ,"Ngultrum"                         ,"BTN",   0.0},
  {"BIELORUSSIE"                                                           ,"Rouble biélorusse"                ,"BYB",   0.0},
  {"BOLIVIE"                                                               ,"Boliviano"                        ,"BOB",   0.0},
  {"BOSNIE-HERZEGOVINE"                                                    ,"Mark convertible"                 ,"BAM",   0.0},
  {"BOTSWANA"                                                              ,"Pula"                             ,"BWP",   0.0},
  {"BRESIL"                                                                ,"Real"                             ,"BRL",   0.0},
  {"BRUNEI"                                                                ,"Dollar de Brunei"                 ,"BND",   0.0},
  {"BULGARIE"                                                              ,"Lev"                              ,"BGL",   0.0},
  // Page 5
  {"BURUNDI"                                                               ,"Franc de Burundi"                 ,"BIF",   0.0},
  {"CAIMANS"                                                               ,"Dollar des Iles Caïmans"          ,"KYD",   0.0},
  {"CAMBODGE"                                                              ,"Riel"                             ,"KHR",   0.0},
  {"CAMEROUN/REP.CENTRAFRICAINE/CONGO/GABON/GUINEE EQUATORIALE/TCHAD"      ,"Franc CFA"                        ,"XAF",   0.0},
  {"CANADA"                                                                ,"Dollar canadien"                  ,"CAD",   0.0},
  {"CAP-VERT (Iles du)"                                                    ,"Escudo du Cap-Vert"               ,"CVE",   0.0},
  {"CARAIBES DE L'EST"                                                     ,"Dollar des Caraïbes de l'Est"     ,"XCD",   0.0},
  {"CHILI"                                                                 ,"Peso chilien"                     ,"CLP",   0.0},
  // Page 6
  {"CHINE"                                                                 ,"Renminbi yuan"                    ,"CNY",   0.0},
  {"CHYPRE"                                                                ,"Livre chypriote"                  ,"CYP",   0.0},
  {"COLOMBIE"                                                              ,"Peso colombien"                   ,"COP",   0.0},
  {"COMORES"                                                               ,"Franc des Comores"                ,"KMF",   0.0},
  {"CONGO (République démocratique)"                                       ,"Franc congolais"                  ,"CDF",   0.0},
  {"COREE DU NORD"                                                         ,"Won"                              ,"KPW",   0.0},
  {"COREE DU SUD"                                                          ,"Won"                              ,"KRW",   0.0},
  {"COSTA-RICA"                                                            ,"Colon de Costa-Rica"              ,"CRC",   0.0},
  // Page 7
  {"CROATIE"                                                               ,"Kuna"                             ,"HRK",   0.0},
  {"CUBA"                                                                  ,"Peso cubain"                      ,"CUP",   0.0},
  {"DANEMARK"                                                              ,"Couronne danoise"                 ,"DKK",   0.0},
  {"DJIBOUTI"                                                              ,"Franc de Djibouti"                ,"DJF",   0.0},
  {"DOMINICAINE (République)"                                              ,"Peso dominicain"                  ,"DOP",   0.0},
  {"EGYPTE"                                                                ,"Livre égyptienne"                 ,"EGP",   0.0},
  {"EMIRATS ARABES UNIS"                                                   ,"Dirham"                           ,"AED",   0.0},
  {"EQUATEUR"                                                              ,"Sucre"                            ,"ECS",   0.0},
  // Page 8
  {"ERYTHREE"                                                              ,"Nakfa"                            ,"ERN",   0.0},
  {"ESPAGNE"                                                               ,"Peseta"                           ,"ESP", 166.386},
  {"ESTONIE"                                                               ,"Couronne estonienne"              ,"EEK",   0.0},
  {"ETATS-UNIS"                                                            ,"Dollar des Etats-Unis"            ,"USD",   0.0},
  {"ETHIOPIE"                                                              ,"Birr éthiopien"                   ,"ETB",   0.0},
  {"FALKLAND (Iles)"                                                       ,"Livre des Falkland"               ,"FKP",   0.0},
  {"FIDJI (Iles)"                                                          ,"Dollar des Iles Fidji"            ,"FJD",   0.0},
  {"FINLANDE"                                                              ,"Mark finlandais"                  ,"FIM",   5.94573},
  {"FONDS MONETAIRE INTERNATIONAL"                                         ,"Droit de tirage spécial (DTS)"    ,"XDR",   0.0},
  {"FRANCE"                                                                ,"Franc français"                   ,"FRF",   6.55957},
  // Page 9
  {"GAMBIE"                                                                ,"Dalasi"                           ,"GMD",   0.0},
  {"GHANA"                                                                 ,"Cedi"                             ,"GHC",   0.0},
  {"GIBRALTAR"                                                             ,"Livre de Gibraltar"               ,"GIP",   0.0},
  {"GRECE"                                                                 ,"Drachme"                          ,"GRD", 340.75},
  {"GUATEMALA"                                                             ,"Quetzal"                          ,"GTQ",   0.0},
  {"GUINEE"                                                                ,"Franc guinéen"                    ,"GNF",   0.0},
  // Page 10
  {"GUYANA"                                                                ,"Dollar de Guyana"                 ,"GYD",   0.0},
  {"HAITI"                                                                 ,"Gourde"                           ,"HTG",   0.0},
  {"HONDURAS"                                                              ,"Lempira"                          ,"HNL",   0.0},
  {"HONG KONG"                                                             ,"Dollar de Hong Kong"              ,"HKD",   0.0},
  {"HONGRIE"                                                               ,"Forint"                           ,"HUF",   0.0},
  {"INDE"                                                                  ,"Roupie"                           ,"INR",   0.0},
  {"INDONESIE"                                                             ,"Rupiah"                           ,"IDR",   0.0},
  {"IRAN (République islamique)"                                           ,"Rial iranien"                     ,"IRR",   0.0},
  {"IRAQ"                                                                  ,"Dinar iraquien"                   ,"IQD",   0.0},
  // Page 11
  {"IRLANDE"                                                               ,"Livre irlandaise"                 ,"IEP",   0.787564},
  {"ISLANDE"                                                               ,"Couronne islandaise"              ,"ISK",   0.0},
  {"ISRAEL"                                                                ,"Sheqel"                           ,"ILS",   0.0},
  {"ITALIE"                                                                ,"Lire italienne"                   ,"ITL",1936.27},
  {"JAMAIQUE"                                                              ,"Dollar jamaïquain"                ,"JMD",   0.0},
  {"JAPON"                                                                 ,"Yen"                              ,"JPY",   0.0},
  {"JORDANIE"                                                              ,"Dinar jordanien"                  ,"JOD",   0.0},
  {"KAZAKHSTAN"                                                            ,"Tenge"                            ,"KZT",   0.0},
  {"KENYA"                                                                 ,"Shilling du Kenya"                ,"KES",   0.0},
  // Page 12
  {"KOWEIT"                                                                ,"Dinar koweïtien"                  ,"KWD",   0.0},
  {"LAOS"                                                                  ,"Kip"                              ,"LAK",   0.0},
  {"LESOTHO"                                                               ,"Loti"                             ,"LSL",   0.0},
  {"LETTONIE"                                                              ,"Lats"                             ,"LVL",   0.0},
  {"LIBAN"                                                                 ,"Livre libanaise"                  ,"LBP",   0.0},
  {"LIBERIA"                                                               ,"Dollar libérien"                  ,"LRD",   0.0},
  {"LIBYE"                                                                 ,"Dinar libyen"                     ,"LYD",   0.0},
  {"LITUANIE"                                                              ,"Litas"                            ,"LTL",   0.0},
  {"LUXEMBOURG"                                                            ,"Franc luxembourgeois"             ,"LUF",  40.3399},
  // Page 13
  {"MACAO"                                                                 ,"Pataca"                           ,"MOP",   0.0},
  {"MACEDOINE"                                                             ,"Denar"                            ,"MKD",   0.0},
  {"MADAGASCAR"                                                            ,"Franc malgache"                   ,"MGF",   0.0},
  {"MALAISIE"                                                              ,"Ringgit"                          ,"MYR",   0.0},
  {"MALAWI"                                                                ,"Kwacha"                           ,"MWK",   0.0},
  {"MALDIVES"                                                              ,"Rufiyaa"                          ,"MVR",   0.0},
  {"MALTE"                                                                 ,"Livre maltaise"                   ,"MTL",   0.0},
  {"MAROC"                                                                 ,"Dirham marocain"                  ,"MAD",   0.0},
  // Page 14
  {"MAURICE (Ile)"                                                         ,"Roupie mauricienne"               ,"MUR",   0.0},
  {"MAURITANIE"                                                            ,"Ouguiya"                          ,"MRO",   0.0},
  {"MEXIQUE"                                                               ,"Peso mexicain"                    ,"MXN",   0.0},
  {"MOLDAVIE"                                                              ,"Leu"                              ,"MDL",   0.0},
  {"MONGOLIE"                                                              ,"Tugrik"                           ,"MNT",   0.0},
  {"MOZAMBIQUE"                                                            ,"Métical"                          ,"MZM",   0.0},
  {"MYANMAR"                                                               ,"Kyat"                             ,"MMK",   0.0},
  {"NAMIBIE"                                                               ,"Dollar namibien"                  ,"NAD",   0.0},
  {"NEPAL"                                                                 ,"Roupie népalaise"                 ,"NPR",   0.0},
  // Page 15
  {"NICARAGUA"                                                             ,"Cordoba oro"                      ,"NIO",   0.0},
  {"NIGERIA"                                                               ,"Naira"                            ,"NGN",   0.0},
  {"NORVEGE"                                                               ,"Couronne norvégienne"             ,"NOK",   0.0},
  {"NOUVELLE-CALEDONIE/POLYNESIE française"                                ,"Franc CFP"                        ,"XPF",   0.0},
  {"NOUVELLE-ZELANDE"                                                      ,"Dollar néo-zélandais"             ,"NZD",   0.0},
  {"OMAN"                                                                  ,"Rial omanais"                     ,"OMR",   0.0},
  {"OUGANDA"                                                               ,"Shilling ougandais"               ,"UGX",   0.0},
  {"OUZBEKISTAN"                                                           ,"Soum"                             ,"UZS",   0.0},
  // Page 16
  {"PAKISTAN"                                                              ,"Roupie pakistanaise"              ,"PKR",   0.0},
  {"PANAMA"                                                                ,"Balboa"                           ,"PAB",   0.0},
  {"PAPOUASIE NOUVELLE-GUINEE"                                             ,"Kina"                             ,"PGK",   0.0},
  {"PARAGUAY"                                                              ,"Guarani"                          ,"PYG",   0.0},
  {"PAYS-BAS"                                                              ,"Florin néerlandais"               ,"NLG",   2.20371},
  {"PEROU"                                                                 ,"Nouveau sol"                      ,"PEN",   0.0},
  {"PHILIPPINES"                                                           ,"Peso philippin"                   ,"PHP",   0.0},
  {"POLOGNE"                                                               ,"Zloty"                            ,"PLN",   0.0},
  // Page 17
  {"PORTUGAL"                                                              ,"Escudo"                           ,"PTE", 200.482},
  {"QATAR"                                                                 ,"Rial du Qatar"                    ,"QAR",   0.0},
  {"ROUMANIE"                                                              ,"Leu"                              ,"ROL",   0.0},
  {/*"ROYAUME-UNI*/"GRANDE BRETAGNE"                                       ,"Livre sterling"                   ,"GBP",   0.0},
  {"RUSSIE"                                                                ,"Nouveau rouble"                   ,"RUB",   0.0},
  {"RWANDA"                                                                ,"Franc rwandais"                   ,"RWF",   0.0},
  {"SALOMON (Iles)"                                                        ,"Dollar des Iles Salomon"          ,"SBD",   0.0},
  {"SALVADOR"                                                              ,"Colon du Salvador"                ,"SVC",   0.0},
  {"SAMOA occidentales"                                                    ,"Tala"                             ,"WST",   0.0},
  // Page 18
  {"SAO TOME et PRINCIPE"                                                  ,"Dobra"                            ,"STD",   0.0},
  {"SEYCHELLES"                                                            ,"Roupie des Seychelles"            ,"SCR",   0.0},
  {"SIERRA LEONE"                                                          ,"Leone"                            ,"SLL",   0.0},
  {"SINGAPOUR"                                                             ,"Dollar de Singapour"              ,"SGD",   0.0},
  {"SLOVAQUIE"                                                             ,"Couronne slovaque"                ,"SKK",   0.0},
  {"SLOVENIE"                                                              ,"Tolar"                            ,"SIT",   0.0},
  {"SOMALIE"                                                               ,"Shilling de Somalie"              ,"SOS",   0.0},
  {"SOUDAN"                                                                ,"Dinar soudanais"                  ,"SDD",   0.0},
  // Page 19
  {"SRI LANKA"                                                             ,"Roupie de Sri Lanka"              ,"LKR",   0.0},
  {"SUEDE"                                                                 ,"Couronne suédoise"                ,"SEK",   0.0},
  {"SUISSE"                                                                ,"Franc suisse"                     ,"CHF",   0.0},
  {"SURINAM"                                                               ,"Florin de Surinam"                ,"SRG",   0.0},
  {"SWAZILAND"                                                             ,"Lilangeni"                        ,"SZL",   0.0},
  {"SYRIE"                                                                 ,"Livre syrienne"                   ,"SYP",   0.0},
  {"TAIWAN"                                                                ,"Nouveau dollar de Taïwan"         ,"TWD",   0.0},
  {"TANZANIE"                                                              ,"Shilling tanzanien"               ,"TZS",   0.0},
  // Page 20
  {"TCHEQUE (République)"                                                  ,"Couronne tchèque"                 ,"CZK",   0.0},
  {"THAILANDE"                                                             ,"Baht"                             ,"THB",   0.0},
  {"TONGA"                                                                 ,"Pa'anga"                          ,"TOP",   0.0},
  {"TRINITE et TOBAGO"                                                     ,"Dollar de Trinité et Tobago"      ,"TTD",   0.0},
  {"TUNISIE"                                                               ,"Dinar tunisien"                   ,"TND",   0.0},
  {"TURQUIE"                                                               ,"Livre turque"                     ,"TRL",   0.0},
  {"UKRAINE"                                                               ,"Hryvnia"                          ,"UAH",   0.0},
  {"UNION EUROPEENNE"                                                      ,"Euro"                             ,"EUR",   0.0},
  // Page 21
  {"URUGUAY"                                                               ,"Peso uruguayen"                   ,"UYU",   0.0},
  {"VANUATA"                                                               ,"Vatu"                             ,"VUV",   0.0},
  {"VENEZUELA"                                                             ,"Bolivar"                          ,"VEB",   0.0},
  {"VIETNAM"                                                               ,"Dong"                             ,"VND",   0.0},
  {"YEMEN"                                                                 ,"Rial du Yémen"                    ,"YER",   0.0},
  {"YOUGOSLAVIE"                                                           ,"Nouveau dinar yougoslave"         ,"YUM",   0.0},
  {"ZAMBIE"                                                                ,"Kwacha"                           ,"ZMK",   0.0},
  {"ZIMBABWE"                                                              ,"Dollar du Zimbabwe"               ,"ZWD",   0.0},
};
int __fastcall TrierListeDevises(TStringList *List, int Index1, int Index2)
{
  CDevise *Dev1,*Dev2;
  Dev1 = (CDevise *)List->Objects[Index1];
  Dev2 = (CDevise *)List->Objects[Index2];
  if (Dev1 < Dev2)
    return -1;
  if (Dev1 == Dev2)
    return 0;
  return 1;
}
__fastcall CInitDevises::CInitDevises()
{
  CEditDevise::CM_LstDevises = new TStringList();

  TStrings *pItems = CEditDevise::CM_LstDevises;
//            pItems->Clear();

  for (int i = 0;i < ARRAYSIZE(ToutesLesDevises);i++)
    pItems->AddObject(ToutesLesDevises[i].CodeDevise,(TObject *)new CDevise/*String*/(ToutesLesDevises[i].NomPays,ToutesLesDevises[i].NomDevise,ToutesLesDevises[i].CodeDevise,ToutesLesDevises[i].Taux));

  // Tri la liste par nom de devise
  ASSERT(dynamic_cast<TStringList*>(pItems));
/*  for(int i=pItems->Count-1; i>=0; i--) pItems->Strings[i] = ((CDevise*)pItems->Objects[i])->Nom;
  ((TStringList*)pItems)->Sort();
  for(int i=pItems->Count-1; i>=0; i--) pItems->Strings[i] = ((CDevise*)pItems->Objects[i])->CodeISO;*/
  ((TStringList*)pItems)->CustomSort(TrierListeDevises);

  DeviseChangeDefaut( DeviseCodeEuro);

  #ifdef _DEBUG
  // Vérifie que les tous les codes devise sont différents
  for(int i=pItems->Count-1; i>=0; i--) {
    CDevise *pDevInfos = (CDevise*)pItems->Objects[i];
    for(int j=pItems->Count-1; j>=0; j--) {
      if ((((CDevise*)pItems->Objects[j])->Code==pDevInfos->Code) && (i!=j)) {
        EICAttention(AnsiString(pDevInfos->CodeISO+"  "+pDevInfos->Pays).c_str());
        break;
      }
    }
  }
  #endif

}
//---------------------------------------------------------------------------
__fastcall CInitDevises::~CInitDevises()
{
  TStrings *pItems = CEditDevise::CM_LstDevises;
  // Détruit toutes les infos des devises
  for(int i=pItems->Count-1; i>=0; i--) {
    delete (CDevise*)pItems->Objects[i];
                     pItems->Objects[i] = NULL;
  }
  // Détruits l'objet liste des devises
  delete CEditDevise::CM_LstDevises;
         CEditDevise::CM_LstDevises = NULL;
}
//---------------------------------------------------------------------------
namespace Cdevise
{
    void __fastcall PACKAGE Register()
    {
        TComponentClass classes[1] = {__classid(CEditDevise)};
        RegisterComponents("EIC Ctrlstd", classes, 0);
    }
}
//---------------------------------------------------------------------------
